const vscode = require('vscode');
const fs = require('fs-extra');
const path = require('path');
const configManager = require('./configManager');

/**
 * 模板添加模块
 */
class TemplateAdder {
    /**
     * 添加到模板库
     * @param {vscode.Uri} sourceUri 源文件/文件夹URI
     * @returns {Promise<void>}
     */
    static async addToTemplateLibrary(sourceUri) {
        try {
            // 获取所有模板源配置
            const templateSources = configManager.getTemplateSourcesConfig();
            
            // 创建选项列表，包括已有模板源和新建选项
            const options = [
                ...templateSources.map(source => ({
                    label: source.name,
                    description: source.type === 'local' ? source.path : source.address,
                    source: source
                })),
                {
                    label: '$(add) 新建模板库...',
                    description: '创建新的模板库',
                    isCreateNew: true
                }
            ];
            
            // 显示QuickPick
            const selected = await vscode.window.showQuickPick(options, {
                placeHolder: '选择目标模板库'
            });
            
            if (!selected) {
                vscode.window.showInformationMessage('已取消添加模板操作');
                return false; // 用户取消了选择
            }
            
            let result;
            if (selected.isCreateNew) {
                // 创建新的模板库
                result = await this.createNewTemplateLibrary(sourceUri);
            } else {
                // 添加到现有模板库
                result = await this.addToExistingTemplateLibrary(sourceUri, selected.source);
            }
            
            // 只有当操作真正完成时才显示成功消息
            if (result !== false) {
                vscode.window.showInformationMessage('模板添加成功！');
            }
        } catch (error) {
            console.error('添加到模板库失败:', error);
            throw error;
        }
    }

    /**
     * 创建新的模板库
     * @param {vscode.Uri} sourceUri 源文件/文件夹URI
     * @returns {Promise<void>}
     */
    static async createNewTemplateLibrary(sourceUri) {
        try {
            // 选择模板库类型
            const libraryTypeOptions = [
                { label: '本地文件系统', value: 'local' },
                { label: 'Git仓库', value: 'git' }
            ];
            
            const selectedType = await vscode.window.showQuickPick(libraryTypeOptions.map(option => ({
                label: option.label,
                value: option.value
            })), {
                placeHolder: '选择模板库类型'
            });
            
            if (!selectedType) {
                vscode.window.showInformationMessage('已取消添加模板操作');
                return false; // 用户取消了选择
            }
            
            const libraryType = selectedType.value;
            
            // 获取模板库名称
            const libraryName = await vscode.window.showInputBox({
                prompt: '输入新模板库的名称',
                placeHolder: '我的模板库',
                validateInput: (value) => {
                    if (!value) {
                        return '名称不能为空';
                    }
                    return null;
                }
            });
            
            if (!libraryName) {
                vscode.window.showInformationMessage('已取消添加模板操作');
                return false; // 用户取消了输入
            }
            
            if (libraryType === 'local') {
                // 获取本地模板库路径
                const libraryPath = await vscode.window.showInputBox({
                    prompt: '输入新模板库的路径',
                    placeHolder: 'C:\\Templates',
                    validateInput: (value) => {
                        if (!value) {
                            return '路径不能为空';
                        }
                        return null;
                    }
                });
                
                if (!libraryPath) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消了输入
                }
                
                // 验证并创建路径
                if (!configManager.validateLocalPath(libraryPath)) {
                    throw new Error(`无法创建模板库路径: ${libraryPath}`);
                }
                
                // 创建新的模板库配置
                const newLibrary = {
                    type: libraryType,
                    path: libraryPath,
                    name: libraryName
                };
                
                // 添加到配置
                await configManager.addTemplateSourceConfig(newLibrary);
                
                // 复制源文件/文件夹到新模板库
                const sourcePath = sourceUri.fsPath;
                const targetPath = path.join(libraryPath, path.basename(sourcePath));
                
                await fs.copy(sourcePath, targetPath);
            } else if (libraryType === 'git') {
                // 获取Git仓库URL
                const repoUrl = await vscode.window.showInputBox({
                    prompt: '输入Git仓库URL',
                    placeHolder: 'https://github.com/user/repo.git',
                    validateInput: (value) => {
                        if (!value) {
                            return 'URL不能为空';
                        }
                        return null;
                    }
                });
                
                if (!repoUrl) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消了输入
                }
                
                // 获取本地路径
                const localPath = await vscode.window.showInputBox({
                    prompt: '输入本地存储路径',
                    placeHolder: 'C:\\Templates\\git-repo',
                    validateInput: (value) => {
                        if (!value) {
                            return '路径不能为空';
                        }
                        return null;
                    }
                });
                
                if (!localPath) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消了输入
                }
                
                // 获取分支名称
                const branch = await vscode.window.showInputBox({
                    prompt: '输入分支名称（可选）',
                    placeHolder: 'master',
                });
                
                // 获取仓库内子路径
                const repoPath = await vscode.window.showInputBox({
                    prompt: '输入仓库内子路径（可选）',
                    placeHolder: '/src/templates',
                });
                
                // 创建新的模板库配置
                const newLibrary = {
                    type: libraryType,
                    url: repoUrl,
                    localPath: localPath,
                    name: libraryName
                };
                
                if (branch) {
                    newLibrary.branch = branch;
                }
                
                if (repoPath) {
                    newLibrary.path = repoPath;
                }
                
                // 添加到配置
                await configManager.addTemplateSourceConfig(newLibrary);
                
                // 从Git URL中提取仓库名称
                const repoName = repoUrl.split('/').pop().replace('.git', '');
                
                // 构建完整的仓库本地路径（localPath + 仓库名称）
                const fullRepoPath = path.join(localPath, repoName);
                
                // 修改配置对象中的localPath为完整路径，以便ensureGitRepository正确处理
                const gitConfig = {...newLibrary, localPath: fullRepoPath};
                
                // 确保Git仓库已克隆
                await configManager.ensureGitRepository(gitConfig);
                
                // 构建目标路径
                let targetBasePath = fullRepoPath;
                if (repoPath) {
                    targetBasePath = path.join(fullRepoPath, repoPath.replace(/^\//, ''));
                }
                
                // 确保目标路径存在
                await fs.ensureDir(targetBasePath);
                
                // 复制源文件/文件夹到Git仓库
                const sourcePath = sourceUri.fsPath;
                const sourceBaseName = path.basename(sourcePath);
                
                // 询问用户输入模板名称
                const templateName = await vscode.window.showInputBox({
                    prompt: '请输入模板名称',
                    placeHolder: sourceBaseName,
                    value: sourceBaseName,
                    validateInput: (value) => {
                        if (!value) {
                            return '名称不能为空';
                        }
                        return null;
                    }
                });
                
                if (!templateName) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消了输入
                }
                
                const targetPath = path.join(targetBasePath, templateName);
                
                // 检查目标路径是否已存在
                if (fs.existsSync(targetPath)) {
                    const overwrite = await vscode.window.showQuickPick(
                        ['是', '否'],
                        {
                            placeHolder: `${templateName} 已存在于模板库中，是否覆盖？`
                        }
                    );
                    
                    if (overwrite !== '是') {
                        vscode.window.showInformationMessage('已取消添加模板操作');
                        return false; // 用户取消了覆盖
                    }
                    
                    // 删除现有文件/文件夹
                    await fs.remove(targetPath);
                }
                
                // 显示进度提示
                await vscode.window.withProgress({
                    location: vscode.ProgressLocation.Notification,
                    title: `正在复制 ${sourceBaseName} 到模板库...`,
                    cancellable: false
                }, async (progress) => {
                    progress.report({ increment: 50 });
                    await fs.copy(sourcePath, targetPath);
                    progress.report({ increment: 50 });
                });
                
                // 询问是否推送到远程仓库
                const shouldPush = await vscode.window.showQuickPick(
                    [
                        { label: '是', value: true },
                        { label: '否', value: false }
                    ],
                    { placeHolder: '是否立即推送到远程仓库？' }
                );
                
                if (shouldPush && shouldPush.value) {
                    try {
                        // 使用正确的仓库路径进行推送
                        const pushConfig = {...newLibrary, localPath: fullRepoPath};
                        
                        // 显示进度提示
                        await vscode.window.withProgress({
                            location: vscode.ProgressLocation.Notification,
                            title: "正在推送到远程仓库...",
                            cancellable: false
                        }, async (progress) => {
                            progress.report({ increment: 30, message: "准备提交..." });
                            
                            // 延迟一下以显示进度
                            await new Promise(resolve => setTimeout(resolve, 500));
                            
                            progress.report({ increment: 30, message: "执行提交..." });
                            await configManager.pushGitRepository(pushConfig, `添加模板: ${templateName}`);
                            
                            progress.report({ increment: 40, message: "完成推送" });
                        });
                        
                        vscode.window.showInformationMessage('已成功推送到远程仓库');
                    } catch (error) {
                        vscode.window.showErrorMessage(`推送到远程仓库失败: ${error.message}，请手动推送`);
                    }
                } else {
                    vscode.window.showInformationMessage('模板已添加到本地Git仓库，请手动推送到远程仓库');
                }
        }
        } catch (error) {
            console.error('创建新模板库失败:', error);
            throw error;
        }
    }

    /**
     * 添加到现有模板库
     * @param {vscode.Uri} sourceUri 源文件/文件夹URI
     * @param {Object} targetSource 目标模板源
     * @returns {Promise<void>}
     */
    static async addToExistingTemplateLibrary(sourceUri, targetSource) {
        try {
            const sourcePath = sourceUri.fsPath;
            const sourceBaseName = path.basename(sourcePath);
            
            // 获取模板库中已有的文件和文件夹名称
            let existingItems = [];
            let targetBasePath;
            
            try {
                if (targetSource.type === 'local') {
                    targetBasePath = targetSource.path;
                } else {
                    // 从Git URL中提取仓库名称
                    const repoName = targetSource.url.split('/').pop().replace('.git', '');
                    // 构建完整的仓库本地路径
                    const fullRepoPath = path.join(targetSource.localPath, repoName);
                    targetBasePath = targetSource.path ? path.join(fullRepoPath, targetSource.path.replace(/^\//, '')) : fullRepoPath;
                }
                
                // 确保目录存在
                await fs.ensureDir(targetBasePath);
                
                const items = await fs.readdir(targetBasePath);
                existingItems = items.map(item => {
                    const isDir = fs.statSync(path.join(targetBasePath, item)).isDirectory();
                    return {
                        label: item,
                        description: isDir ? '文件夹' : '文件'
                    };
                });
            } catch (error) {
                console.error('读取模板库内容失败:', error);
                // 即使读取失败，也继续后续流程
            }
            
            // 获取模板文件名
            let templateName = null;
            let targetPath = null;
            let retry = true;
            
            while (retry) {
                // 先使用QuickPick显示现有文件列表作为建议
                const quickPickItems = [
                    { label: '输入新的文件/文件夹名', description: '输入新的文件/文件夹名' },
                    { label: sourceBaseName, description: '(默认当前选择文件/文件夹名)' },
                    ...existingItems
                ];
                
                const selectedItem = await vscode.window.showQuickPick(quickPickItems, {
                    placeHolder: '选择或输入模板文件/文件夹名 (可以输入新名称)',
                    ignoreFocusOut: true
                });
                
                if (!selectedItem) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消选择
                }

                if (selectedItem.label === '输入新的文件/文件夹名') {
                    // 输入新的文件/文件夹名
                    templateName = await vscode.window.showInputBox({
                        prompt: '输入新的文件/文件夹名',
                        validateInput: (value) => {
                            if (!value || value.trim().length === 0) {
                                return '文件名不能为空';
                            }
                            return null;
                        },
                        ignoreFocusOut: true
                    });
                } else {
                    // 使用选择的项目作为默认值，让用户可以编辑
                    templateName = await vscode.window.showInputBox({
                        prompt: '确认或修改模板文件名',
                        value: selectedItem.label,
                        validateInput: (value) => {
                            if (!value || value.trim().length === 0) {
                                return '文件名不能为空';
                            }
                            return null;
                        },
                        ignoreFocusOut: true
                    });
                }
                
                if (!templateName) {
                    vscode.window.showInformationMessage('已取消添加模板操作');
                    return false; // 用户取消输入
                }
                
                // 构建目标路径
                if (targetSource.type === 'local') {
                    targetPath = path.join(targetSource.path, templateName);
                } else {
                    targetPath = path.join(targetBasePath, templateName);
                }
                
                // 检查目标路径是否已存在
                if (await fs.pathExists(targetPath)) {
                    const isDirectory = (await fs.stat(targetPath)).isDirectory();
                    const itemType = isDirectory ? '文件夹' : '文件';
                    
                    const overwrite = await vscode.window.showQuickPick(
                        ['是', '否'],
                        {
                            placeHolder: `模板库中已存在名为 "${templateName}" 的${itemType}，是否覆盖？`,
                            ignoreFocusOut: true
                        }
                    );
                    
                    if (overwrite === '是') {
                        // 删除现有文件或文件夹
                        await fs.remove(targetPath);
                        retry = false; // 结束循环
                    } else if (overwrite === '否') {
                        // 用户选择不覆盖，继续循环让用户重新输入文件名
                        continue;
                    } else {
                        // 用户取消操作
                        vscode.window.showInformationMessage('已取消添加模板操作');
                        return false;
                    }
                } else {
                    // 文件不存在，可以直接写入
                    retry = false;
                }
            }
            
            if (targetSource.type === 'local') {
                // 添加到本地模板库
                const targetPath = path.join(targetSource.path, templateName);
                
                // 检查目标路径是否已存在
                if (fs.existsSync(targetPath)) {
                    const overwrite = await vscode.window.showQuickPick(
                        ['是', '否'],
                        {
                            placeHolder: `${templateName} 已存在于模板库中，是否覆盖？`
                        }
                    );
                    
                    if (overwrite !== '是') {
                        vscode.window.showInformationMessage('已取消添加模板操作');
                        return false; // 用户取消了覆盖
                    }
                    
                    // 删除现有文件/文件夹
                    await fs.remove(targetPath);
                }
                
                // 显示进度提示
                await vscode.window.withProgress({
                    location: vscode.ProgressLocation.Notification,
                    title: `正在复制 ${sourceBaseName} 到模板库...`,
                    cancellable: false
                }, async (progress) => {
                    progress.report({ increment: 50 });
                    // 复制到模板库
                    await fs.copy(sourcePath, targetPath);
                    progress.report({ increment: 50 });
                });
            } else if (targetSource.type === 'git') {
                // 从Git URL中提取仓库名称
                const repoName = targetSource.url.split('/').pop().replace('.git', '');
                
                // 构建完整的仓库本地路径（localPath + 仓库名称）
                const fullRepoPath = path.join(targetSource.localPath, repoName);
                
                // 修改配置对象中的localPath为完整路径，以便ensureGitRepository正确处理
                const gitConfig = {...targetSource, localPath: fullRepoPath};
                
                // 确保Git仓库已克隆并更新
                await configManager.ensureGitRepository(gitConfig);
                
                // 构建目标路径
                let targetBasePath = fullRepoPath;
                if (targetSource.path) {
                    targetBasePath = path.join(fullRepoPath, targetSource.path.replace(/^\//, ''));
                }
                
                // 确保目标路径存在
                await fs.ensureDir(targetBasePath);
                
                // 构建目标文件路径
                const targetPath = path.join(targetBasePath, templateName);
                
                // 检查目标路径是否已存在
                if (fs.existsSync(targetPath)) {
                    const overwrite = await vscode.window.showQuickPick(
                        ['是', '否'],
                        {
                            placeHolder: `${templateName} 已存在于模板库中，是否覆盖？`
                        }
                    );
                    
                    if (overwrite !== '是') {
                        vscode.window.showInformationMessage('已取消添加模板操作');
                        return false; // 用户取消了覆盖
                    }
                    
                    // 删除现有文件/文件夹
                    await fs.remove(targetPath);
                }
                
                // 显示进度提示
                await vscode.window.withProgress({
                    location: vscode.ProgressLocation.Notification,
                    title: `正在复制 ${sourceBaseName} 到模板库...`,
                    cancellable: false
                }, async (progress) => {
                    progress.report({ increment: 50 });
                    // 复制源文件/文件夹到Git仓库
                    await fs.copy(sourcePath, targetPath);
                    progress.report({ increment: 50 });
                });
                
                // 询问是否推送到远程仓库
                const shouldPush = await vscode.window.showQuickPick(
                    [
                        { label: '是', value: true },
                        { label: '否', value: false }
                    ],
                    { placeHolder: '是否立即推送到远程仓库？' }
                );
                
                if (shouldPush && shouldPush.value) {
                    try {
                        await configManager.pushGitRepository(targetSource, `添加模板: ${sourceBaseName}`);
                        vscode.window.showInformationMessage('已成功推送到远程仓库');
                    } catch (error) {
                        vscode.window.showErrorMessage(`推送到远程仓库失败: ${error.message}，请手动推送`);
                    }
                } else {
                    vscode.window.showInformationMessage('模板已添加到本地Git仓库，请手动推送到远程仓库');
                }
            } else {
                throw new Error(`不支持的模板源类型: ${targetSource.type}`);
            }
        } catch (error) {
            console.error('添加到现有模板库失败:', error);
            throw error;
        }
    }


}

module.exports = TemplateAdder;